package com.imooc.lock;
import com.imooc.mmall.common.Const;
import com.imooc.redis.RedisShardedPoolUtil;
import com.imooc.redis.RedissonManager;
import com.imooc.utils.PropertiesUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.redisson.api.RLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * spring 定时器
 */
@Component
@Slf4j
public class CloseOrderTask {

    @Autowired
    private RedissonManager redissonManager;

//    cron 在线生成 http://cron.qqe2.com/
//    @Scheduled(cron="0 0 0 * * ?") //每天0点一次
//    @Scheduled(cron="0 0 23 * * ?") //每天23点一次
//    @Scheduled(cron="0 */1 * * * ?")//每一分钟(每个1分钟的整数倍)
//    @Scheduled(cron="0 0 */6 * * ?")//每6小时(每个6小时的整数倍)
//    @Scheduled(cron="0 0 */1 * * ?")//每一小时(每个1小时的整数倍)
    /**
     * 没有分布式锁，运行起来来看日志。
     */
    //@Scheduled(cron="0 */1 * * * ?")//每1分钟(每个1分钟的整数倍)
    public void closeOrderTaskV1(){
        log.info("我是定时器，每1分钟跑一次");
    }



    private static String lockName="order_lock";
    /**
     * 可能出现死锁，虽然在执行close的时候有防死锁，但是还是会出现，继续演进V3
     */
//    @Scheduled(cron="0 */10 * * * ?")
    public void closeOrderTaskV2() throws InterruptedException {
        Long setnxResult = RedisShardedPoolUtil.setnx(lockName, String.valueOf(System.currentTimeMillis()+5000));
        if(setnxResult != null && setnxResult.intValue() == 1){
            //如果返回值是1，代表设置成功，获取锁
            log.info("拿到分布式锁:{}",lockName);
            //模拟关闭订单耗时
            Thread.sleep(1000);
            RedisShardedPoolUtil.del(lockName);//释放锁
        }else{
            log.info("没有获得分布式锁:{}",lockName);
        }
    }


    /**
     * 防死锁之分布式锁
     * @throws InterruptedException
     */
//    @Scheduled(cron="0 */1 * * * ?")//每1分钟(每个1分钟的整数倍)
    public void closeOrderTaskV3() throws InterruptedException {
        //防死锁分布式锁
        long lockTimeout = 50000l;//锁50秒有效期


        //这个时间如何用呢，看下面。和时间戳结合起来用。
        Long setnxResult = RedisShardedPoolUtil.setnx(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, String.valueOf(System.currentTimeMillis()+lockTimeout));
        if(setnxResult != null && setnxResult.intValue() == 1){
            //如果返回值是1，代表设置成功，获取锁
            Thread.sleep(1000);
            RedisShardedPoolUtil.del(lockName);//释放锁
        }else{
            //如果setnxResult==null 或 setnxResult.intValue() ==0 即 != 1的时候
            //未获取到锁，继续判断,判断时间戳,看是否可以重置获取到锁
            String lockValueStr = RedisShardedPoolUtil.get(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);

            //如果lockValue不是空,并且当前时间大于锁的有效期,说明之前的lock的时间已超时,执行getset命令.
            if(lockValueStr != null && System.currentTimeMillis() > Long.parseLong(lockValueStr)){
                String getSetResult = RedisShardedPoolUtil.getSet(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,String.valueOf(System.currentTimeMillis()+lockTimeout));
                //再次用当前时间戳getset，
                //返回给定 key 的旧值。  ->旧值判断，是否可以获取锁
                // 当 key 没有旧值时，即 key 不存在时，返回 nil 。 ->获取锁
                //这里我们set了一个新的value值，获取旧的值。
                if(getSetResult == null || (getSetResult !=null && StringUtils.equals(lockValueStr,getSetResult))){
                    //获取到锁
                    //模拟关闭订单耗时
                    Thread.sleep(1000);
                    RedisShardedPoolUtil.del(lockName);//释放锁
                }else{
                    log.info("没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
                }
            }else{
                log.info("没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
            }
        }
    }


    /**
     * Redisson分布式锁实现
     * @throws InterruptedException
     */
//    @Scheduled(cron="0 */1 * * * ?")//每1分钟(每个1分钟的整数倍)
    public void closeOrderTaskV4() throws InterruptedException {
        RLock lock = redissonManager.getRedisson().getLock(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
        boolean getLock = false;
        try {
            if(getLock = lock.tryLock(2,50, TimeUnit.SECONDS)){//trylock增加锁
                log.info("===获取{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
                int hour = Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour","2"));
                //模拟关闭订单耗时
                Thread.sleep(1000);
            }else{
                log.info("===没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
            }
        }finally {
            if(!getLock){
                return;
            }
            log.info("===释放分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
            lock.unlock();
        }
    }





}
